#include<bits/stdc++.h>
using namespace std;


/*
template<typename T>
struct AVLnode {
	T value;   //value 代表AVL树上的数据域 
	int height; //height代表的是节点的高度 
	AVLnode *lchild, *rchild;
	AVLnode(T temp) : value(temp), height(0), lchild(NULL), rchild(NULL) {}
	AVLnode() {
		this->lchild = NULL;
		this->rchild = NULL;
		this->height = 0; 
	}
}; 

class AVL {
	typedef pair<string, string> pss;  //单词的英文翻译作为key值，单词的英文翻译作为value值 
	private:
		AVLnode<pss> *root;
		
		//分配一个新的节点 
		AVLnode<pss>* newNode(string key, string value) {
			AVLnode<pss>* Node = new AVLnode<pss>(make_pair(key, value));
			return Node;	
		}
		
		
		//获取当前节点的高度 
		int getHeight(AVLnode<pss>* u) {
			if(!u) return 0;
			return u->height;  
		}
		
		
		//获取当前节点的平衡因子 
		int getBalenceFactor(AVLnode<pss> *u) {
			return getHeight(u->lchild) - getHeight(u->rchild);  //平衡因子 = 左子树的高度 - 右子树的高度 
		}
		
		
		//在进行插入，删除操作的同时对调整节点的高度进行更新 
		void updataHeight(AVLnode<pss> *u) {  //当前节点的高度 = max(左子树的高度，右子树的高度) 
			u->height = max(getHeight(u->lchild), getHeight(u->rchild)) + 1;
		}
		
		AVLnode<pss> *getMinValueNode(AVLnode<pss> *u) {
			if(u->lchild) return getMinValueNode(u->lchild);
			return u;
		}
		
	public:
		AVL() { root = NULL; }
		
		AVLnode<pss> *getRoot() {
			return root;
		}
		
		string getKey(AVLnode<pss> *u) {
			return u->value.first;
		}
		
		string getValue(AVLnode<pss> *u) {
			return u->value.second;
		}
		
		void search(AVLnode<pss> *u, string key) {
			//如果该节点为空节点的话，那么说明搜索到树的底层也没有找到节点 
			if(!u) {
				cout << "未找到该节点" << '\n';
				return ;
			}
			//如果等于这个单词的key值的话，说明找到改值 
			if(key == u->value.first) {
				cout << "该单词的的中文翻译为" << u->value.second << '\n';
				return ; 
			} else if(key < u->value.first) {  //如果当前节点的key值的字典序是小于key值的，那么向左子树进行递归 
				search(u->lchild, key);
			} else { //如果当前节点的key值的字典序是大于key值的，那么向右子树进行递归 
				search(u->rchild, key);
			}
		}
		
		//通过左旋来对AVL树进行调整高度 
		void leftRotate(AVLnode<pss>* &u) {
			//temp指向当前节点的右子树 
			AVLnode<pss>* temp = u->rchild;
			//调制的节点的右子树指向他右子树的左子树   
			u->rchild = temp->lchild;    
			//让右子树的左子树指向需要调制的节点 
			temp->lchild = u; 
			//更新调整的两个节点的高度，而他们的子树的高度并未发生该变 
			updataHeight(u);
			updataHeight(temp); 
			u = temp; 
		}
		
		//通过右旋来对AVL树进行调整高度 
		void rightRotate(AVLnode<pss>* &u) {
			//temp指向当前节点的左子树 
			AVLnode<pss> *temp = u->lchild;
			//让调制节点的左子树指向他的左节点的右子树 
			u->lchild = temp->rchild;
			//让temp的右子树指向当前节点
			temp->rchild = u;
			//调整平衡树的高度 
			updataHeight(u);
			updataHeight(temp);
			u = temp; 
		}
		
		//AVL树的插入操作 
		void insert(AVLnode<pss>* &u, string key, string value) {
			if(!u) {  //到达了一个空节点，对新的节点分配内存并赋值 
				u = newNode(key, value);
				return ; 
			}
			//key值小于当前节点的key值，向左进行递归 
			if(key < u->value.first) {
				//往左子树进行插入 
				insert(u->lchild, key, value);
				//调整当前节点的树的高度   
				updataHeight(u);
				if(getBalenceFactor(u) == 2) {
					if(getBalenceFactor(u->lchild) == 1) { //LL型 
						rightRotate(u); 
					} else if(getBalenceFactor(root->lchild) == -1) {  //LR型 
						leftRotate(u->lchild);
						rightRotate(u); 
					} 
				}
			} else { 
				//往右子树进行插入 
				insert(u->rchild, key, value);
				//调整数的高度
				updataHeight(u);
				if(getBalenceFactor(u) == -2) {
					if(getBalenceFactor(u->rchild) == -1) {  //RR型 
						leftRotate(u);
					}	else if(getBalenceFactor(u->rchild) == 1) { //RL型 
						rightRotate(u->rchild);
						leftRotate(u); 
					} 
				} 
			}
		}
		
		//AVL树的建立
		void buildAVL(vector<pss> &data) {
			//事先已经将所有的data存到变长数组vector中 
			int n = data.size();
			for(int i = 0; i < n; i++) 
				insert(root, data[i].first, data[i].second);
		}
		
		//AVL树的删除操作
		void deleteNode(AVLnode<pss>* &u, string key) {
			if(key < u->value.first) {
				deleteNode(u->lchild, key);  //向左子树递归 
				//调整当前节点的树的高度   
				updataHeight(u);
				if(getBalenceFactor(u) == 2) {
					if(getBalenceFactor(u->lchild) == 1) { //LL型 
						rightRotate(u); 
					} else if(getBalenceFactor(root->lchild) == -1) {  //LR型 
						leftRotate(u->lchild);
						rightRotate(u); 
					} 
				}
			}
			else if(key > u->value.first) {
				deleteNode(u->rchild, key);  //向右子树递归
				//调整数的高度
				updataHeight(u);
				if(getBalenceFactor(u) == -2) {
					if(getBalenceFactor(u->rchild) == -1) {  //RR型 
						leftRotate(u);
					}	else if(getBalenceFactor(u->rchild) == 1) { //RL型 
						rightRotate(u->rchild);
						leftRotate(u); 
					} 
				}
			} 
			else {
				//当有一个节点或者没有节点的时候 
				if(!u->lchild || !u->rchild) {
					AVLnode<pss> *temp = NULL;
					//这是步的目的是找到非空的孩子节点 
					if(temp == u->lchild) temp = u->rchild;
					else temp = u->lchild;
					if(temp == NULL) {
						//当没有孩子节点的时候，直接删除当前节点 
						temp = u;
						u = NULL;
						delete u;
					} else {
						//当只有一个孩子节点的时候，经孩子节点的值付给当前的节点 
						u->value.first = temp->value.first;
						u->value.second = temp->value.second;
						temp = NULL;
						delete temp;
					}
				} else {
					//当同时有两个孩子节点的时候，找到当前节点的后继节点
					//也就是右子树当中key的值最小的点 
					AVLnode<pss> *temp = getMinValueNode(u->rchild);
					//将最小后继的值付给当前节点 
					u->value.first = temp->value.first;
					u->value.second = temp->value.second;
					//在找到这个后继节点并将其删除 
					deleteNode(u->rchild, temp->value.first); 
				}
			}
		} 
		
		void deleteNode(string key) {
			deleteNode(root, key); 
		}
};
*/

int main()
{
	ios::sync_with_stdio(0);
	cin.tie(0), cout.tie(0);
	freopen("1.in", "r", stdin);
	for(int CASE = 0; CASE <= 100; CASE++) {
		int op;
		op = rand() % 3; // 对操作的方案进行随机选择  0代表查找操作， 1代表插入，2代表删除操作 
		len = rand() % 30; //英语单词的长度范围在0 - 29；
		string words = "";
		for(int i = 1; i <= len; i++) { //对长度为len的单词进行随机赋值 
			char c;
			while(true) {
				c = rand() % 26;
				c = c + 'a';
				if(c >= 'a' && c <= 'z') break ;
			}
			words += c;
		} 
		
	}
	return 0; 
}
